CU Amiga Super CD-ROM 22/CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso/PowerPC/Programming/PPCSmallEiffel/lib_se/formal_arg_list.e

Text File | 1998-01-16 | 7.0 KB | 326 lines

--          This file is part of SmallEiffel The GNU Eiffel Compiler.
--          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
--            Dominique COLNET and Suzanne COLLIN - [e-mail]
--                       http://www.loria.fr/SmallEiffel
-- SmallEiffel is  free  software;  you can  redistribute it and/or modify it
-- under the terms of the GNU General Public License as published by the Free
-- Software  Foundation;  either  version  2, or (at your option)  any  later
-- version. SmallEiffel is distributed in the hope that it will be useful,but
-- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License
-- for  more  details.  You  should  have  received a copy of the GNU General
-- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
-- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- Boston, MA 02111-1307, USA.
--
class FORMAL_ARG_LIST
   --
   -- For the formal arguments list of a routine.
   --

inherit
   DECLARATION_LIST
      rename make as standard_make
      end;

creation {EIFFEL_PARSER} make

creation {DECLARATION_LIST} runnable_from_current

feature {NONE} -- Parsing creation procedure :

   make(sp: like start_position; l: like list) is
      require
     sp /= Void;
     l.lower = 1;
     not l.empty;
      local
     an: like name;
     tlf: TYPE_LIKE_FEATURE;
     tla, tla2: TYPE_LIKE_ARGUMENT;
     i, rank: INTEGER;
     an2: ARGUMENT_NAME2;
      do
     standard_make(sp,l);
     -- Substitution TYPE_LIKE_FEATURE/TYPE_LIKE_ARGUMENT :
     from
        i := flat_list.upper;
     until
        i = 0
     loop
        an := flat_list.item(i);
        tlf ?= an.result_type;
        if tlf /= Void then
           rank := rank_of(tlf.like_what.to_string);
           if rank = i then
          eh.add_position(tlf.start_position);
          fatal_error(fz_cad);
           elseif rank > 0 then
          !!an2.refer_to(tlf.like_what.start_position,Current,rank);
          !!tla.make(tlf.start_position,an2);
          an.set_result_type(tla);
           end;
        end;
        i := i - 1;
     end;
     if run_control.all_check then
        from
           i := flat_list.upper;
        until
           i = 0
        loop
           tla ?= flat_list.item(i).result_type;
           if tla /= Void then
          rank := rank_of(tla.like_what.to_string);
          tla2 ?= flat_list.item(rank).result_type;
          if tla2 /= Void then
             eh.add_position(tla.start_position);
             eh.add_position(tla2.start_position);
             fatal_error(fz_cad);
          end;
           end;
           i := i - 1;
        end;
     end;
      ensure
     start_position = sp;
     list = list
     flat_list /= Void;
      end;

feature

   name(i: INTEGER): ARGUMENT_NAME1 is
      do
     Result := flat_list.item(i);
      end;

   pretty_print is
      local
     i: INTEGER;
      do
     fmt.put_character('(');
     fmt.level_incr;
     from
        i := 1;
     until
        i > list.upper
     loop
        list.item(i).pretty_print;
        i := i + 1;
        if i <= list.upper then
           fmt.put_string("; ");
        end;
     end;
     fmt.level_decr;
     fmt.put_character(')');
      end;

   short is
      local
     i: INTEGER;
      do
     short_print.hook_or("hook302"," (");
     from
        i := 1;
     until
        i > list.upper
     loop
        list.item(i).short;
        i := i + 1;
        if i <= list.upper then
           short_print.hook_or("hook303"," ;");
        end;
     end;
     short_print.hook_or("hook306",")");
      end;

   compile_to_c_in(str: STRING) is
      local
     i: INTEGER;
     t: TYPE;
      do
     from
        i := 1;
     until
        i > count
     loop
        t := type(i).run_type;
        t.c_type_for_argument_in(str);
        str.extend(' ');
        str.extend('a');
        i.append_in(str);
        i := i + 1;
        if i <= count then
           str.extend(',');
        end;
     end;
      end;

   is_a_in(other: like Current; rc: RUN_CLASS): BOOLEAN is
     -- True when `other' interpreted in `rc' is a kind of Current
     -- interpreted in `rc'.
      require
     other /= Void;
     rc /= Void;
      local
     i: INTEGER;
     t1, t2: TYPE;
      do
     if other.count /= count then
        eh.add_position(other.start_position);
        error(start_position,"Bad number of arguments.");
     end;
     if nb_errors = 0 then
        from
           Result := true;
           i := 1;
        until
           not Result or else i > flat_list.upper
        loop
           t1 := type(i);
           t2 := other.type(i);
           if not t1.is_a_in(t2,rc) then
          Result := false;
          eh.print_as_error;
          eh.add_position(t1.start_position);
          eh.add_position(t2.start_position);
          eh.append("Incompatible types in ");
          eh.append(rc.current_type.run_time_mark);
          eh.error(fz_dot);
           end;
           i := i + 1;
        end;
     end;
      end;

feature {JVM}

   jvm_switch_push(dyn_fal: like Current): INTEGER is
     -- Push inside switching method.
      require
     count = dyn_fal.count
      local
     i: INTEGER;
      do
     from
        i := 1;
     until
        i > count
     loop
        Result := Result + jvm_switch_push_ith(dyn_fal,i);
        i := i + 1;
     end;
      end;

   jvm_switch_push_ith(dyn_fal: like Current; i: INTEGER): INTEGER is
      local
     t1, t2: TYPE;
     offset: INTEGER;
      do
     offset := jvm.argument_offset_of(name(i));
     t1 := type(i).run_type;
     t2 := dyn_fal.type(i).run_type;
     t1.jvm_push_local(offset);
     Result := t1.jvm_convert_to(t2);

--***     if t1.is_reference then
--***        if t2.is_reference then
--***           -- Reference into reference :
--***           Result := 1;
--***        else
--***           -- Reference into expanded :
--***           Result := t1.jvm_to_expanded;
--***        end;
--***     elseif t2.is_expanded then
--***        -- Expanded into expanded :
--***        Result := t2.jvm_stack_space;
--***     else
--***        -- Expanded into reference :
--***        Result := 1;
--***     end;
      end;

feature {RUN_FEATURE,SWITCH}

   jvm_descriptor_in(str: STRING) is
      local
     i: INTEGER;
     at: TYPE;
      do
     from
        i := 1;
     until
        i > count
     loop
        at := type(i).run_type;
        if at.is_reference then
           str.append(jvm_root_descriptor);
        else
           at.jvm_descriptor_in(str);
        end;
        i := i + 1;
     end;
      end;

feature {RUN_FEATURE_3}

   inline_one_pc is
      local
     i: INTEGER;
     t: TYPE;
      do
     from
        i := 1;
     until
        i > count
     loop
        t := type(i).run_type;
        tmp_string.clear;
        t.c_type_for_argument_in(tmp_string);
        tmp_string.extend(' ');
        cpp.put_string(tmp_string);
        cpp.inline_level_incr;
        cpp.print_argument(i);
        cpp.inline_level_decr;
        cpp.put_character('=');
        cpp.put_ith_argument(i);
        cpp.put_string(fz_00);
        i := i + 1;
     end;
      end;

feature {RUN_FEATURE,CECIL_POOL}

   external_prototype(str: STRING) is
      local
     i: INTEGER;
     t: TYPE;
      do
     from
        i := 1;
     until
        i > count
     loop
        t := type(i).run_type;
        t.c_type_for_external_in(str);
        str.extend(' ');
        str.extend('a');
        i.append_in(str);
        i := i + 1;
        if i <= count then
           str.extend(',');
        end;
     end;
      end;

feature {NONE}

   tmp_string: STRING is
      once
     !!Result.make(32);
      end;

end -- FORMAL_ARG_LIST